// pages/activity/detail/detail.js
const activityApi = require('../../../api/activity.js')
const activityItemApi = require('../../../api/activity_item.js')
const util = require('../../../utils/util.js')
const qrcodeUtil = require('../../../utils/qrcode.js')
const api = require('../../../utils/api.js')
const app = getApp()

Page({
  data: {
    activityId: null,
    activity: {},
    isLogin: false,  // 登录状态
    // 二维码弹窗
    showQRModal: false,
    qrcodeImageUrl: '',
    // 报名项目
    allItems: [],
    registeredItems: [],
    unregisteredItems: [],
    displayedItems: [],
    filterType: 'all',  // all | registered | unregistered
    showRegistrations: true,  // 是否展开显示已报名人员
    // 报名时间状态
    registrationOpen: false,  // 是否在报名时间范围内
    registrationStartTime: '',
    registrationEndTime: '',
    // 报名弹窗
    showRegisterModal: false,
    currentItem: {},
    registerForm: {
      name: '',
      introduction: '',
      photo_url: '',
      speech_intro: ''
    },
    // 管理报名弹窗
    showManageModal: false,
    managingItem: {},
    itemRegistrations: []
  },

  onLoad(options) {
    // 处理会议ID（支持scene参数）
    let activityId = options.id
    
    // 从小程序码scene参数中解析ID
    if (options.scene && !activityId) {
      try {
        const sceneDecoded = decodeURIComponent(options.scene)
        console.log('📱 解析scene参数:', sceneDecoded)
        // scene格式: id=19
        const match = sceneDecoded.match(/id=(\d+)/)
        if (match && match[1]) {
          activityId = match[1]
          console.log('✅ 从scene获取activityId:', activityId)
        }
      } catch (error) {
        console.error('❌ 解析scene失败:', error)
      }
    }
    
    if (activityId) {
      this.setData({ activityId: activityId })
      this.loadData()
    }
    
    // 检查登录状态
    const userInfo = wx.getStorageSync('userInfo')
    this.setData({
      isLogin: !!userInfo
    })
    
    // 检查是否是管理员邀请
    if (options.invite === 'manager' && activityId) {
      this.handleManagerInvite(activityId)
    }
  },

  // 处理管理员邀请
  async handleManagerInvite(activityId) {
    // 检查是否登录
    const userInfo = wx.getStorageSync('userInfo')
    
    if (!userInfo) {
      wx.showModal({
        title: '需要登录',
        content: '接受管理员邀请需要先登录，是否前往登录？',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/user/profile/profile',
              success: () => {
                // 登录后需要重新打开此页面并处理邀请
                wx.setStorageSync('pendingManagerInvite', activityId)
              }
            })
          }
        }
      })
      return
    }
    
    // 已登录，显示确认对话框
    try {
      const activity = this.data.activity
      const title = activity.title || '此会议'
      
      wx.showModal({
        title: '管理员邀请',
        content: `是否接受成为"${title}"的管理员？\n\n管理员可以编辑会议、管理报名、发布加油等。`,
        confirmText: '接受',
        cancelText: '拒绝',
        success: async (res) => {
          if (res.confirm) {
            try {
              wx.showLoading({ title: '处理中...' })
              
              // 调用后端API添加管理员
              const result = await api.post(`/activities/${activityId}/managers`, {})
              
              wx.hideLoading()
              
              if (result.success || result.code === 200) {
                util.showSuccess('您已成为管理员')
                // 重新加载页面数据
                this.loadData()
              } else {
                util.showError(result.message || '添加失败')
              }
            } catch (error) {
              wx.hideLoading()
              console.error('接受邀请失败:', error)
              util.showError('处理失败')
            }
          }
        }
      })
    } catch (error) {
      console.error('处理邀请失败:', error)
    }
  },

  async loadData() {
    await Promise.all([
      this.loadActivityDetail(),
      this.loadActivityItems()
    ])
  },

  async loadActivityDetail() {
    try {
      const res = await activityApi.getActivityDetail(this.data.activityId)
      
      if (res.code === 200 || res.success) {
        const activity = res.data || res
        this.setData({ activity })
      } else {
        util.showError(res.message || '加载失败')
      }
    } catch (error) {
      console.error('加载会议详情失败:', error)
      util.showError('加载失败')
    }
  },

  async loadActivityItems() {
    try {
      const res = await activityItemApi.getActivityItems(this.data.activityId)
      
      if (res.code === 200 || res.success) {
        const items = res.data?.items || []
        const registrationOpen = res.data?.registration_open || false
        const registrationStartTime = res.data?.registration_start_time || ''
        const registrationEndTime = res.data?.registration_end_time || ''
        
        // 分类项目
        const registeredItems = items.filter(item => item.registration_count > 0)
        const unregisteredItems = items.filter(item => item.registration_count === 0)
        
        this.setData({
          allItems: items,
          registeredItems,
          unregisteredItems,
          displayedItems: items,
          registrationOpen,
          registrationStartTime,
          registrationEndTime
        })
        
        console.log('📅 报名时间状态:', { registrationOpen, registrationStartTime, registrationEndTime })
      }
    } catch (error) {
      console.error('加载报名项目失败:', error)
    }
  },

  // 切换过滤条件
  switchFilter(e) {
    const type = e.currentTarget.dataset.type
    let displayedItems = []
    
    if (type === 'all') {
      displayedItems = this.data.allItems
    } else if (type === 'registered') {
      displayedItems = this.data.registeredItems
    } else if (type === 'unregistered') {
      displayedItems = this.data.unregisteredItems
    }
    
    this.setData({
      filterType: type,
      displayedItems
    })
  },

  // 打开地图
  openMap() {
    const { latitude, longitude, address } = this.data.activity
    
    if (latitude && longitude) {
      wx.openLocation({
        latitude: parseFloat(latitude),
        longitude: parseFloat(longitude),
        name: '会议地址',
        address: address,
        scale: 15
      })
    } else {
      util.showError('未设置地址信息')
    }
  },

  // ========== 报名弹窗相关 ==========

  openRegisterModal(e) {
    const item = e.currentTarget.dataset.item
    
    // 检查登录
    if (!app.globalData.userInfo) {
      wx.showModal({
        title: '提示',
        content: '请先登录后再报名',
        confirmText: '去登录',
        success: (res) => {
          if (res.confirm) {
            wx.switchTab({ url: '/pages/user/profile/profile' })
          }
        }
      })
      return
    }
    
    // 检查报名时间
    if (!this.data.registrationOpen) {
      util.showError('当前不在报名时间范围内')
      return
    }
    
    // 检查是否已满员
    if (item.is_full) {
      util.showError(`该项目报名人数已满（最多${item.max_registrations}人）`)
      return
    }
    
    this.setData({
      showRegisterModal: true,
      currentItem: item,
      registerForm: {
        name: app.globalData.userInfo.name || '',
        introduction: '',
        photo_url: '',
        speech_intro: ''
      }
    })
  },

  closeRegisterModal() {
    this.setData({
      showRegisterModal: false,
      currentItem: {},
      registerForm: {
        name: '',
        introduction: '',
        photo_url: '',
        speech_intro: ''
      }
    })
  },

  preventClose() {
    // 阻止冒泡，防止点击内容区域关闭弹窗
  },

  onRegisterInput(e) {
    const field = e.currentTarget.dataset.field
    this.setData({
      [`registerForm.${field}`]: e.detail.value
    })
  },

  // 选择/拍摄照片
  choosePhoto() {
    wx.showActionSheet({
      itemList: ['拍照', '从相册选择'],
      success: (res) => {
        const sourceType = res.tapIndex === 0 ? ['camera'] : ['album']
        
        wx.chooseImage({
          count: 1,
          sizeType: ['compressed'],
          sourceType: sourceType,
          success: (res) => {
            const tempFilePath = res.tempFilePaths[0]
            
            // 这里简化处理，直接使用本地路径
            // 在实际使用中，应该上传到服务器获取URL
            this.setData({
              'registerForm.photo_url': tempFilePath
            })
            
            util.showSuccess('照片已选择')
          },
          fail: (err) => {
            console.log('选择照片失败:', err)
            // 用户拒绝隐私授权
            if (err.errMsg && (err.errMsg.includes('104') || err.errMsg.includes('privacy'))) {
              wx.showModal({
                title: '需要授权',
                content: '为了上传个人照片，需要您同意隐私保护指引。',
                showCancel: false,
                confirmText: '我知道了'
              })
            } else if (!err.errMsg || !err.errMsg.includes('cancel')) {
              util.showError('选择照片失败')
            }
          }
        })
      }
    })
  },

  // 提交报名
  async submitRegister() {
    const { name, introduction, photo_url, speech_intro } = this.data.registerForm
    const item = this.data.currentItem

    // 验证姓名（必填）
    if (!name.trim()) {
      util.showError('请输入"我是谁"')
      return
    }

    // 根据项目设置验证必填项
    if (item.require_introduction && !introduction.trim()) {
      util.showError('请输入自我介绍')
      return
    }

    if (item.require_photo && !photo_url) {
      util.showError('请上传个人照片')
      return
    }

    if (item.require_speech_intro && !speech_intro.trim()) {
      util.showError('请输入演讲介绍')
      return
    }

    try {
      wx.showLoading({ title: '提交中...' })
      
      // 如果照片是本地路径（wxfile://），先上传到服务器
      let finalPhotoUrl = photo_url
      if (photo_url && photo_url.startsWith('wxfile://')) {
        console.log('📤 上传报名照片到服务器...')
        try {
          const token = wx.getStorageSync('token')
          const BASE_URL = 'https://naturedao.tech/api/v1'
          
          const uploadRes = await new Promise((resolve, reject) => {
            wx.uploadFile({
              url: `${BASE_URL}/upload`,
              filePath: photo_url,
              name: 'file',
              formData: {
                'type': 'registration_photo'
              },
              header: {
                'Authorization': `Bearer ${token}`
              },
              success: (res) => {
                const data = JSON.parse(res.data)
                if (data.code === 200 || data.success) {
                  resolve(data.data.url)
                } else {
                  reject(new Error(data.message || '上传失败'))
                }
              },
              fail: reject
            })
          })
          
          finalPhotoUrl = uploadRes
          console.log('✅ 照片上传成功:', finalPhotoUrl)
        } catch (uploadError) {
          wx.hideLoading()
          console.error('❌ 照片上传失败:', uploadError)
          util.showError('照片上传失败，请重试')
          return
        }
      }
      
      // 提交报名信息（使用服务器照片URL）
      const res = await activityItemApi.registerForItem(
        this.data.activityId,
        this.data.currentItem.id,
        {
          ...this.data.registerForm,
          photo_url: finalPhotoUrl
        }
      )

      wx.hideLoading()

      if (res.code === 200 || res.success) {
        util.showSuccess('报名成功')
        this.closeRegisterModal()
        // 重新加载项目列表
        this.loadActivityItems()
      } else {
        util.showError(res.message || '报名失败')
      }
    } catch (error) {
      wx.hideLoading()
      console.error('报名失败:', error)
      util.showError('报名失败，请重试')
    }
  },

  // 取消报名（用户自己）
  async cancelRegistration(e) {
    const item = e.currentTarget.dataset.item
    const registrationId = item.user_registration_id

    if (!registrationId) {
      util.showError('报名记录不存在')
      return
    }

    wx.showModal({
      title: '确认取消',
      content: `确定要取消报名"${item.name}"吗？`,
      confirmColor: '#e74c3c',
      success: async (res) => {
        if (res.confirm) {
          try {
            wx.showLoading({ title: '取消中...' })
            
            const result = await activityItemApi.cancelRegistration(
              this.data.activityId,
              item.id,
              registrationId
            )

            wx.hideLoading()

            if (result.code === 200 || result.success) {
              util.showSuccess('取消成功')
              // 重新加载项目列表
              this.loadActivityItems()
            } else {
              util.showError(result.message || '取消失败')
            }
          } catch (error) {
            wx.hideLoading()
            console.error('取消报名失败:', error)
            util.showError('取消失败，请重试')
          }
        }
      }
    })
  },

  // 管理报名（创建者查看并取消他人报名）
  async manageRegistrations(e) {
    const item = e.currentTarget.dataset.item
    
    try {
      wx.showLoading({ title: '加载中...' })
      
      // 获取该项目的所有报名记录
      const res = await activityItemApi.getItemRegistrations(this.data.activityId, item.id)
      
      wx.hideLoading()
      
      if (res.code === 200 || res.success) {
        this.setData({
          showManageModal: true,
          managingItem: item,
          itemRegistrations: res.data.registrations || []
        })
      } else {
        util.showError('获取报名列表失败')
      }
    } catch (error) {
      wx.hideLoading()
      console.error('获取报名列表失败:', error)
      util.showError('加载失败，请重试')
    }
  },

  // 关闭管理报名弹窗
  closeManageModal() {
    this.setData({
      showManageModal: false,
      managingItem: {},
      itemRegistrations: []
    })
  },

  // 取消某个报名（管理员操作）
  async cancelOtherRegistration(e) {
    const registration = e.currentTarget.dataset.registration
    
    wx.showModal({
      title: '确认取消',
      content: `确定要取消 ${registration.name} 的报名吗？`,
      confirmColor: '#e74c3c',
      success: async (res) => {
        if (res.confirm) {
          try {
            wx.showLoading({ title: '取消中...' })
            
            const result = await activityItemApi.cancelRegistration(
              this.data.activityId,
              this.data.managingItem.id,
              registration.id
            )

            wx.hideLoading()

            if (result.code === 200 || result.success) {
              util.showSuccess('取消成功')
              // 重新加载报名列表
              this.manageRegistrations({ currentTarget: { dataset: { item: this.data.managingItem } } })
              // 重新加载项目列表
              this.loadActivityItems()
            } else {
              util.showError(result.message || '取消失败')
            }
          } catch (error) {
            wx.hideLoading()
            console.error('取消报名失败:', error)
            util.showError('取消失败，请重试')
          }
        }
      }
    })
  },

  // 编辑会议（仅创建者或管理员）
  editActivity() {
    wx.navigateTo({
      url: `/pages/admin/activity/edit/edit?id=${this.data.activityId}`
    })
  },

  // 发布会议
  async publishActivity() {
    try {
      const res = await activityApi.publishActivity(this.data.activityId)
      
      if (res.code === 200 || res.success) {
        util.showSuccess('会议已发布')
        this.loadActivityDetail()
      } else {
        util.showError(res.message || '发布失败')
      }
    } catch (error) {
      console.error('发布失败:', error)
      util.showError('发布失败')
    }
  },

  // 分享给好友/群聊
  onShareAppMessage() {
    const { activity, isInvitingManager } = this.data
    const activityId = this.data.activityId
    
    // 如果是邀请管理员模式
    if (isInvitingManager) {
      return {
        title: `邀请您成为"${activity.title}"的管理员`,
        path: `/pages/activity/detail/detail?id=${activityId}&invite=manager`,
        imageUrl: '/assets/images/activity01.jpg',
        success: () => {
          this.setData({ isInvitingManager: false })
          util.showSuccess('邀请已发送')
        }
      }
    }
    
    // 普通分享
    return {
      title: activity.title || '探索语言成长社会议',
      path: `/pages/activity/detail/detail?id=${activityId}`,
      imageUrl: '/assets/images/activity01.jpg'
    }
  },

  // 分享到朋友圈
  onShareTimeline() {
    const { activity } = this.data
    const activityId = this.data.activityId
    
    return {
      title: activity.title || '探索语言成长社会议',
      query: `id=${activityId}`,
      imageUrl: '/assets/images/activity01.jpg'
    }
  },

  // 生成二维码
  async generateQRCode() {
    const { activity } = this.data
    const activityId = this.data.activityId
    
    try {
      wx.showLoading({ title: '生成小程序码中...' })
      
      // 调用后端生成微信小程序码
      const apiModule = require('../../../utils/api.js')
      const BASE_URL = 'https://naturedao.tech/api/v1'
      const qrcodeUrl = `${BASE_URL}/activities/${activityId}/wxacode?t=${Date.now()}`
      
      console.log('📱 小程序码URL:', qrcodeUrl)
      
      wx.hideLoading()
      
      // 显示二维码弹窗
      this.setData({
        showQRModal: true,
        qrcodeImageUrl: qrcodeUrl,
        qrcodeTitle: activity.title
      })
      
      console.log('✅ 小程序码URL:', qrcodeUrl)
      
    } catch (error) {
      wx.hideLoading()
      console.error('生成小程序码失败:', error)
      util.showError('生成失败')
    }
  },

  // 导出会议报名信息到Excel
  async exportActivityToExcel() {
    try {
      wx.showLoading({ title: '生成中...' })
      
      const token = wx.getStorageSync('token')
      const BASE_URL = 'https://naturedao.tech/api/v1'
      const exportUrl = `${BASE_URL}/activities/${this.data.activityId}/export?token=${token}`
      
      console.log('📊 导出URL:', exportUrl)
      
      wx.downloadFile({
        url: exportUrl,
        success: (res) => {
          if (res.statusCode === 200) {
            // 先保存文件到本地
            wx.saveFile({
              tempFilePath: res.tempFilePath,
              success: (saveRes) => {
                wx.hideLoading()
                const savedFilePath = saveRes.savedFilePath
                
                // 使用外部应用打开（允许选择应用和保存）
                wx.openDocument({
                  filePath: savedFilePath,
                  fileType: 'xlsx',
                  showMenu: true,  // 显示分享和保存菜单
                  success: () => {
                    console.log('✅ 打开Excel成功')
                    util.showSuccess('文件已生成，可选择应用打开或保存')
                  },
                  fail: (error) => {
                    console.error('❌ 打开Excel失败:', error)
                    util.showError('文件已下载，但打开失败')
                  }
                })
              },
              fail: (error) => {
                wx.hideLoading()
                console.error('❌ 保存文件失败:', error)
                util.showError('文件保存失败')
              }
            })
          } else {
            wx.hideLoading()
            util.showError('导出失败')
          }
        },
        fail: (error) => {
          wx.hideLoading()
          console.error('❌ 导出失败:', error)
          util.showError('导出失败')
        }
      })
    } catch (error) {
      wx.hideLoading()
      console.error('❌ 导出失败:', error)
      util.showError('导出失败')
    }
  },

  // 关闭二维码弹窗
  closeQRModal() {
    this.setData({
      showQRModal: false
    })
  },

  // 保存二维码
  saveQRCode() {
    const { qrcodeImageUrl } = this.data
    
    wx.downloadFile({
      url: qrcodeImageUrl,
      success: (res) => {
        if (res.statusCode === 200) {
          wx.saveImageToPhotosAlbum({
            filePath: res.tempFilePath,
            success: () => {
              util.showSuccess('已保存到相册')
            },
            fail: (error) => {
              if (error.errMsg.includes('auth')) {
                util.showError('请授权访问相册')
              } else {
                util.showError('保存失败')
              }
            }
          })
        }
      },
      fail: () => {
        util.showError('下载失败')
      }
    })
  },

  // 转发二维码
  shareQRCode() {
    wx.showModal({
      title: '分享二维码',
      content: '可以长按二维码图片保存后发送给好友，或点击右上角"···"使用小程序分享功能。',
      showCancel: false
    })
  },

  // 准备邀请管理员（设置标志）
  prepareInviteManager() {
    // 设置邀请管理员模式，点击按钮后会直接触发分享
    this.setData({ isInvitingManager: true })
  },

  // 进入加油页面
  goToVote() {
    wx.navigateTo({
      url: `/pages/activity/vote/vote?id=${this.data.activityId}`
    })
  }
})
